#pragma once

#include "subtasks/task_base.h"
#include "kernel/task/task_entity.h"
#include "kernel/interfaces/ILogger.h"
#include "application/vehicle/vehicle_service.h"
#include <QObject>
#include <QTimer>
#include <QList>
#include <memory>
#include <vector>
#include <string>

namespace application {
namespace dispatcher {
class DispatcherService;
}
class MapApplicationService;
namespace area {
class Area;
}
namespace charge {
class ChargePoint;
}
namespace park {
class ParkPoint;
}
namespace lift {
class BaseLift;
}
namespace task {

/**
 * @brief 任务链状态
 * @details 参考三方代码 TaskChainHandle_s 和 task_process_info_t
 */
struct TaskChainState {
    // 任务链ID（唯一标识）
    std::string chainId;

    // AGV编号
    int agvNumber{-1};

    // 子任务列表（可动态修改）
    std::vector<std::unique_ptr<SubTaskBase>> tasks;

    // 当前执行的任务索引
    size_t currentTaskIndex{0};

    // 任务上下文
    TaskContext context;

    // 任务链执行状态（参考三方代码的状态管理）
    kernel::task::TaskChainStatus status{kernel::task::TaskChainStatus::Ok};

    // 是否暂停
    bool paused{false};

    // 任务链是否完成
    bool finished{false};

    // 任务链创建时间
    std::chrono::system_clock::time_point createTime;

    // ==================== 扩展字段（参考三方） ====================

    // 挂起计数器（用于Suspend状态）
    int suspendCount{0};

    // 中间移动站点（用于DispatcherMove状态）
    std::string midMoveStation;

    // 占用的区域列表（用于资源管理）
    std::vector<std::weak_ptr<area::Area>> occupiedAreas;

    // 电梯指针（当前使用的电梯）
    std::weak_ptr<lift::BaseLift> liftPtr;

    // 充电桩指针（当前使用的充电桩）
    std::weak_ptr<charge::ChargePoint> chargePtr;

    // 泊车位指针（当前使用的泊车位）
    std::weak_ptr<park::ParkPoint> parkPtr;

    // 任务名称（用于UI显示）
    std::string taskName;

    // 界面索引（用于UI更新，可选）
    int uiIndex{-1};
};

/**
 * @brief 任务执行器 - 管理和执行任务链
 * @details 替代三方代码中的TaskChain
 *          使用定时器定期执行任务链中的子任务
 */
class TaskExecutor : public QObject {
    Q_OBJECT

public:
    explicit TaskExecutor(
        std::shared_ptr<kernel::ILogger> logger,
        std::shared_ptr<vehicle::VehicleService> vehicleService,
        std::shared_ptr<dispatcher::DispatcherService> dispatcherService,
        std::shared_ptr<MapApplicationService> mapService,
        QObject* parent = nullptr
    );
    ~TaskExecutor() override;

    /**
     * @brief 添加任务链
     * @param agvNumber AGV编号
     * @param tasks 子任务列表
     * @param taskName 任务名称（可选）
     * @return 任务链ID
     */
    std::string addTaskChain(
        int agvNumber,
        std::vector<std::unique_ptr<SubTaskBase>> tasks,
        const std::string& taskName = ""
    );

    /**
     * @brief 暂停任务链
     * @param chainId 任务链ID
     * @return 是否成功
     */
    bool pauseTaskChain(const std::string& chainId);

    /**
     * @brief 恢复任务链
     * @param chainId 任务链ID
     * @return 是否成功
     */
    bool resumeTaskChain(const std::string& chainId);

    /**
     * @brief 取消任务链
     * @param chainId 任务链ID
     * @return 是否成功
     */
    bool cancelTaskChain(const std::string& chainId);

    /**
     * @brief 在当前任务前插入新任务
     * @details 参考三方代码 taskchain.cpp:309-345 的动态任务插入
     * @param chainId 任务链ID
     * @param task 要插入的任务
     * @return 是否成功
     */
    bool insertTaskBeforeCurrent(
        const std::string& chainId,
        std::unique_ptr<SubTaskBase> task
    );

    /**
     * @brief 在当前任务后插入新任务
     * @param chainId 任务链ID
     * @param task 要插入的任务
     * @return 是否成功
     */
    bool insertTaskAfterCurrent(
        const std::string& chainId,
        std::unique_ptr<SubTaskBase> task
    );

    /**
     * @brief 设置任务链状态
     * @param chainId 任务链ID
     * @param status 新状态
     * @return 是否成功
     */
    bool setChainStatus(
        const std::string& chainId,
        kernel::task::TaskChainStatus status
    );

    /**
     * @brief 获取任务链状态
     * @param chainId 任务链ID
     * @return 任务链状态指针，不存在返回nullptr
     */
    const TaskChainState* getTaskChainState(const std::string& chainId) const;

    /**
     * @brief 获取所有活跃的任务链ID
     * @return 任务链ID列表
     */
    std::vector<std::string> getActiveChainIds() const;

    /**
     * @brief 获取指定AGV的任务链ID
     * @param agvNumber AGV编号
     * @return 任务链ID列表
     */
    std::vector<std::string> getChainIdsByAgv(int agvNumber) const;
    /**
     * @brief 指定AGV是否存在未完成的任务链
     */
    bool hasActiveChainForAgv(int agvNumber) const;
    /**
     * @brief 是否存在指定任务名称的活跃任务链
     */
    bool hasActiveTaskByName(const std::string& taskName) const;

    /**
     * @brief 启动执行器
     */
    void start();

    /**
     * @brief 停止执行器
     */
    void stop();

    /**
     * @brief 重置当前子任务状态为Init
     * @param chainId 任务链ID
     * @return 是否成功
     */
    bool resetCurrentSubTask(const std::string& chainId);

    /**
     * @brief 设置执行间隔（毫秒）
     * @param intervalMs 间隔时间
     */
    void setExecutionInterval(int intervalMs);

signals:
    /**
     * @brief 任务链完成信号
     * @param chainId 任务链ID
     * @param success 是否成功
     */
    void taskChainCompleted(const QString& chainId, bool success);

    /**
     * @brief 任务链进度更新信号
     * @param chainId 任务链ID
     * @param currentTask 当前任务索引
     * @param totalTasks 总任务数
     */
    void taskChainProgressUpdated(
        const QString& chainId,
        int currentTask,
        int totalTasks
    );

    /**
     * @brief 任务链状态更新信号
     * @param chainId 任务链ID
     * @param status 状态描述
     */
    void taskChainStatusUpdated(const QString& chainId, const QString& status);

    /**
     * @brief 任务链添加信号
     * @param chainId 任务链ID
     * @param agvNumber AGV编号
     * @param taskName 任务名称
     */
    void taskChainAdded(const QString& chainId, int agvNumber, const QString& taskName);

    /**
     * @brief 任务链移除信号
     * @param chainId 任务链ID
     */
    void taskChainRemoved(const QString& chainId);

private slots:
    /**
     * @brief 执行单步（定时器触发）
     */
    void executeStep();

private:
    std::shared_ptr<kernel::ILogger> m_logger;
    std::shared_ptr<vehicle::VehicleService> m_vehicleService;
    std::shared_ptr<dispatcher::DispatcherService> m_dispatcherService;
    std::shared_ptr<MapApplicationService> m_mapService;

    // 活跃的任务链列表
    std::vector<TaskChainState> m_activeChains;

    // 执行定时器
    QTimer m_executionTimer;

    // 执行间隔（毫秒）
    int m_executionInterval{1000};  // 默认1秒

    /**
     * @brief 生成唯一的任务链ID
     * @return 任务链ID
     */
    std::string generateChainId();

    /**
     * @brief 查找任务链
     * @param chainId 任务链ID
     * @return 任务链状态指针，不存在返回nullptr
     */
    TaskChainState* findTaskChain(const std::string& chainId);

    /**
     * @brief 执行单个任务链
     * @param chain 任务链状态
     */
    void executeSingleChain(TaskChainState& chain);

    /**
     * @brief 处理路径重计算状态
     * @details 参考 taskchain.cpp:297-346
     * @param chain 任务链状态
     * @param currentTask 当前任务
     */
    void handleRecalculation(TaskChainState& chain, SubTaskBase* currentTask);

    /**
     * @brief 处理移动到管控区外状态
     * @details 参考 taskchain.cpp:348-364
     * @param chain 任务链状态
     */
    void handleDispatcherMove(TaskChainState& chain);
    void handleDispatchEvent(int agvNumber, const QList<QString>& segment);

    /**
     * @brief 完成任务链
     * @param chain 任务链状态
     * @param success 是否成功
     */
    void finishTaskChain(TaskChainState& chain, bool success);

    /**
     * @brief 移除已完成的任务链
     */
    void removeFinishedChains();

    /**
     * @brief 将任务上下文中的请求同步到任务链状态
     */
    void applyContextUpdates(TaskChainState& chain);

    /**
     * @brief 根据 AGV 当前地图解析所在楼层
     */
    int resolveAgvFloor(const TaskChainState& chain) const;

    /**
     * @brief 释放任务链占用的资源
     */
    void releaseResources(TaskChainState& chain);

    // 任务链计数器（用于生成ID）
    static std::atomic<uint64_t> s_chainCounter;
};

} // namespace task
} // namespace application
